package extraction;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.Map.Entry;
import java.util.TreeMap;



/**
 * Cette classe contient les statistiques et données pour une categorie spécifique
 * (positive, negative, neutral ou irrelevant).
 * 
 *
 */
public class Categorie {

	/** Tableau static contenant les différents type de polarité à analyser. */
	private static String []typePolarite = { "positive", "negative", "neutral", "irrelevant", "test_positive", "test_negative", "test_neutral", "test_irrelevant" };

	/** Polarité des mots de cette instance. */
	String polarite;

	/** Contient tous les tweets d'une catégorie. */
	private ArrayList<Tweet> listeTweet;

	/** HashMap qui contient en clé un mot et en valeur son nombre d'occurences. */
	private HashMap<String, Integer> motsOcc;

	/** HashMap qui contient en clé un mot et en valeur le nombre de tweet dans lequel il apparait*/
	private HashMap<String, Integer> motsTweet;

	public Categorie (String polarite) {
		this.polarite = polarite;
		motsOcc = new HashMap<String, Integer>();
		listeTweet = new ArrayList<Tweet>();
		motsTweet = new HashMap<String, Integer>();
	}

	/**
	 * Méthode qui rajoute un mot dans la map en incrémentant son nombre d'occurence.
	 * @param mot : le mot a inséré dans la map.
	 */
	public void addMotOcc (String mot) {
		// Si le mot n'est pas déjà dans la map
		if (null == motsOcc.get(mot)) {
			motsOcc.put(mot, 1);
		}
		else { // Sinon s'il existe deja, on incrément son occurence
			motsOcc.put(mot, motsOcc.get(mot)+1);
		}
	}


	/**
	 * Méthode qui permet d'insérer un objet Tweet dans la liste des tweets de cette
	 * catégorie.
	 * @param t : le Tweet à insérer.
	 */
	public void addTweet (Tweet t){
		this.listeTweet.add(t);
	}

	/**
	 * Insére une liste de mots.
	 * @param result
	 */
	public void addListeMotsOcc(ArrayList<String> result) {
		for (String mot : result) {
			// Si le mot n'est pas déjà dans la map
			if (null == motsOcc.get(mot)) {
				motsOcc.put(mot, 1);
			}
			else { // Sinon s'il existe deja, on incrément son occurence
				motsOcc.put(mot, motsOcc.get(mot)+1);
			}
		}

	}

	/**
	 * Pour chacun des mots passés en parametre, rajoute le nombre de tweet dans lequel
	 * il apparait.
	 * @param result
	 */
	public void addListeMotsTweet(ArrayList<String> result) {
		ArrayList<String> motsPasses = new ArrayList<String>();
		for (String mot : result) {
			if(!motsPasses.contains(mot)){
				// Si le mot n'est pas déjà dans la map
				if (null == motsTweet.get(mot)) {
					motsTweet.put(mot, 1);
				}
				else { // Sinon s'il existe deja, on incrément le nbre de Tweet dans lequel il apparait
					motsTweet.put(mot, motsTweet.get(mot)+1);
				}
			}
			motsPasses.add(mot);
		}
	}

	public int getOccurencesTotales(){
		int tot = 0;
		for (Entry<String, Integer> mot : motsOcc.entrySet()){
			tot += mot.getValue();
		}
		return tot;

	}

	/**
	 * Retourne le nombre total de mots contenus dans cette classe.
	 * @return
	 */
	public static Integer getNbMotsTotal (HashMap<String, Integer> mots) {

		// Nombre total de mots
		int nbOccMotsTotal = 0;
		for (Integer nb : mots.values()){
			nbOccMotsTotal += nb;
		}

		return nbOccMotsTotal;

	}

	/**
	 * Retourne le nombre de mots differents
	 * @return
	 */
	public static Integer getNbMotsDifferents (HashMap<String, Integer> mots) {
		return mots.size();
	}



	/**
	 * Méthode qui retourne le nombre de tweets contenus dans cette classe.
	 * @return
	 */
	public Integer getNbTweets() {
		return listeTweet.size();	
	}

	/**
	 * Méthode qui calcul la longueur moyenne des tweets.
	 * @return
	 */
	public double longueurMoyenneTweet () {
		double longueur = 0.0;

		for (Tweet t : listeTweet) {
			longueur += t.getLongueurMessage();
		}

		return longueur/listeTweet.size();
	}

	public HashMap<String, Integer> getMotsTweet() {
		return motsTweet;
	}

	public HashMap<String, Integer> getMotsOcc() {
		return motsOcc;
	}

	public static String [] getTypePolarite() {
		return typePolarite;
	}

	public ArrayList<Tweet> getListeTweet() {
		return listeTweet;
	}

	public String getPolarite() {
		return polarite;
	}

	/**
	 * Méthode qui retourne le nombre de tweet de cette classe dans lequel le mot 
	 * apprait.
	 * @param mot
	 * @return
	 */
	public Integer getNbTweetCategorie(String mot) {
		int nbTweet = 0;
		for (Tweet t : listeTweet){
			if (t.motPresent(mot))
				nbTweet++;
		}

		return nbTweet++;
	}

	/**
	 * Méthode qui retourne le nombre de tweet de cette polarité dans 
	 * lesquels le mot n'est pas présent.
	 * @param mot
	 * @return
	 */
	public Integer getNbTweetNonPresent(String mot) {
		int nbTweet = 0;
		return (listeTweet.size() - getNbTweetCategorie(mot));
	}


}

